package com.erp.framework.service.impl;


import com.erp.framework.constant.ConfigConstants;
import com.erp.framework.constant.Constants;
import com.erp.framework.core.domain.AjaxResult;
import com.erp.framework.domain.SysRole;
import com.erp.framework.domain.SysUser;
import com.erp.framework.domain.SysUserRole;
import com.erp.framework.exception.BusinessException;
import com.erp.framework.mapper.SysUserMapper;
import com.erp.framework.mapper.SysUserRoleMapper;
import com.erp.framework.service.ISysConfigService;
import com.erp.framework.service.ISysRoleService;
import com.erp.framework.service.ISysUserService;
import com.erp.framework.util.AutoFillUtils;
import com.erp.framework.util.ShiroUtils;
import com.erp.framework.util.StringUtils;
import com.erp.framework.util.security.Md5Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 用户 业务层处理
 *
 * @author erp
 */
@Service
public class SysUserServiceImpl implements ISysUserService {

    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);

    @Autowired
    private SysUserMapper userMapper;

    @Autowired
    private ISysRoleService roleService;

    @Autowired
    private SysUserRoleMapper userRoleMapper;

    @Autowired
    private ISysConfigService configService;

    /**
     * 根据条件分页查询用户列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> list(SysUser user) {
        return userMapper.list(user);
    }


    @Override
    public void checkUserAllowed(SysUser user) {
        if (user.isAdmin() && !ShiroUtils.getSysUser().isAdmin()) {
            throw new BusinessException("无法操作管理员用户");
        }
    }

    /**
     * 根据条件分页查询未分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> selectUnallocatedList(SysUser user) {
        // user 的 id 值 实际是 勾选的 role 的 id
        return userMapper.selectUnallocatedList(user)
                .stream().filter(u -> !u.isAdmin()
                        && ConfigConstants.ENABLE.equals(u.getStatus()))
                .collect(Collectors.toList());
    }

    /**
     * 通过用户名查询用户
     *
     * @param userName 用户名
     * @return 用户对象信息
     */
    @Override
    public SysUser getByUserName(String userName) {
        return userMapper.getByUserName(userName);
    }

    /**
     * 通过用户ID查询用户
     *
     * @param id 用户ID
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserById(String id) {
        SysUser param = new SysUser();
        param.setId(id);
        return list(param).stream().findFirst().orElse(param);
    }

    /**
     * 新增保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insert(SysUser user) {
        AutoFillUtils.setCreateInfo(user);
        // 新增用户信息
        int rows = userMapper.insert(user);
        // 新增用户与角色管理
        insertUserRole(user.getId(), user.getRoleIds());
        return rows;
    }


    /**
     * 修改保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    public int update(SysUser user) {
        // 删除用户与角色关联
        userRoleMapper.deleteUserRoleByUserId(user.getId());
        // 新增用户与角色管理
        insertUserRole(user.getId(), user.getRoleIds());
        AutoFillUtils.setEditInfo(user);
        return userMapper.update(user);
    }

    /**
     * 修改用户个人详细信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserInfo(SysUser user) {
        return userMapper.update(user);
    }


    /**
     * 用户授权角色
     *
     * @param userId  用户ID
     * @param roleIds 角色组
     */
    @Override
    public void insertUserAuth(String userId, String[] roleIds) {
        userRoleMapper.deleteUserRoleByUserId(userId);
        insertUserRole(userId, roleIds);
    }

    /**
     * 修改用户密码
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int resetUserPwd(SysUser user) {
        return updateUserInfo(user);
    }

    /**
     * 新增用户角色信息
     */
    public void insertUserRole(String userId, String[] roleIds) {
        if (StringUtils.isNotNull(roleIds)) {
            // 新增用户与角色管理
            List<SysUserRole> list = new ArrayList<SysUserRole>();
            for (String roleId : roleIds) {
                SysUserRole ur = new SysUserRole();
                ur.setUserId(userId);
                ur.setRoleId(roleId);
                list.add(ur);
            }
            if (list.size() > 0) {
                userRoleMapper.insertBatch(list);
            }
        }
    }

    /**
     * 校验登录名称是否唯一
     *
     * @param userName 用户名
     * @return
     */
    @Override
    public boolean checkUserNameUnique(String userName) {
        SysUser param = new SysUser();
        param.setUserName(userName);
        return !list(param).isEmpty();
    }

    /**
     * 校验email是否唯一
     *
     * @param email 用户信息
     * @return
     */
    @Override
    public boolean checkEmailUnique(String email) {
        SysUser param = new SysUser();
        param.setEmail(email);
        return !list(param).isEmpty();
    }

    /**
     * 校验手机号码是否唯一
     *
     * @param phoneNumber 用户信息
     * @return
     */
    @Override
    public boolean checkPhoneUnique(String phoneNumber) {
        SysUser param = new SysUser();
        param.setPhoneNumber(phoneNumber);
        return !list(param).isEmpty();
    }

    /**
     * 查询用户所属角色组
     *
     * @param id 用户ID
     * @return 结果
     */
    @Override
    public String selectUserRoleGroup(String id) {
        List<SysRole> list = roleService.selectRolesByUserId(id);
        StringBuilder idsStr = new StringBuilder();
        for (SysRole role : list) {
            idsStr.append(role.getName()).append(",");
        }
        if (StringUtils.isNotEmpty(idsStr.toString())) {
            return idsStr.substring(0, idsStr.length() - 1);
        }
        return idsStr.toString();
    }

    /**
     * 导入用户数据
     *
     * @param userList        用户数据列表
     * @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
     * @return 结果
     */
    @Override
    public AjaxResult importUser(List<SysUser> userList, Boolean isUpdateSupport) {
        if (userList.isEmpty()) {
            return AjaxResult.error("获取导入用户数据失败");
        }
        StringBuilder msg = new StringBuilder();
        String password = configService.selectConfigByKey("sys.user.initPassword");
        for (SysUser user : userList) {
            // 验证是否存在这个用户
            SysUser u = userMapper.getByUserName(user.getUserName());
            if (StringUtils.isNull(u)) {
                user.setPassword(Md5Utils.hash(user.getUserName() + password));
                AutoFillUtils.setCreateInfo(user);
                insert(user);
            } else if (isUpdateSupport) {
                AutoFillUtils.setEditInfo(user);
                update(user);
            } else {
                msg.append("用户[").append(user.getUserName()).append("]已存在").append("<br/>");
            }
        }
        if (msg.length() > 0) {
            return AjaxResult.error(msg.toString());
        }
        return AjaxResult.success("数据已全部导入成功！");
    }

}
